home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1995 February: Tool Chest / Dev.CD Feb 95 / Dev.CD Feb 95.toast / Tool Chest / Development Tools & Languages / • Other Platforms / PCCTS / lang / C / expr.g < prev    next >
Encoding:
Text File  |  1994-09-14  |  6.1 KB  |  342 lines  |  [TEXT/MPS ]
  1. /* "," should group left-to-right; build a tree with all expr0's as siblings;
  2.  *
  3.  *        expr0 --> ... --> expr0
  4.  */
  5. expr    :       expr0
  6.                 (       ","!
  7.                         expr0
  8.                 )*
  9.         ;
  10.  
  11. /* asgnop should group right-to-left; yield
  12.  *
  13.  *        asgnop
  14.  *          |
  15.  *          v
  16.  *        expr1 --> expr0
  17.  */
  18. expr0   :       expr1
  19.                 {       (       "="^
  20.                         |       "\+="^
  21.                         |       "\-="^
  22.                         |       "\*="^
  23.                         |       "/="^
  24.                         |       "\%="^
  25.                         |       "\>\>="^
  26.                         |       "\<\<="^
  27.                         |       "&="^
  28.                         |       "^="^
  29.                         |       "\|="^
  30.                         )
  31.                         expr0
  32.                 }
  33.         ;
  34.  
  35. /*       "?"
  36.  *        |
  37.  *        v
  38.  *      expr2 --> expr2 --> expr2
  39.  */
  40. expr1   :       expr2
  41.                 {       "?"^
  42.                         expr2
  43.                         ":"!
  44.                         expr2
  45.                 }
  46.         ;
  47.  
  48. /*      "||"
  49.  *        |
  50.  *        v
  51.  *      expr3 --> expr3
  52.  */
  53. expr2   :       expr3
  54.                 (       "\|\|"^
  55.                         expr3
  56.                 )*
  57.         ;
  58.  
  59. /*      "&&"
  60.  *        |
  61.  *        v
  62.  *      expr4 --> expr4
  63.  */
  64. expr3   :       expr4
  65.                 (       "&&"^
  66.                         expr4
  67.                 )*
  68.         ;
  69.  
  70. /*       "|"
  71.  *        |
  72.  *        v
  73.  *      expr5 --> expr5
  74.  */
  75. expr4   :       expr5
  76.                 (       "\|"^
  77.                         expr5
  78.                 )*
  79.         ;
  80.  
  81. /*       "^"
  82.  *        |
  83.  *        v
  84.  *      expr6 --> expr6
  85.  */
  86. expr5   :       expr6
  87.                 (       "^"^
  88.                         expr6
  89.                 )*
  90.         ;
  91.  
  92. /*       "&"
  93.  *        |
  94.  *        v
  95.  *      expr7 --> expr7
  96.  */
  97. expr6   :       expr7
  98.                 (       "&"^
  99.                         expr7
  100.                 )*
  101.         ;
  102.  
  103. /*     equ_op
  104.  *        |
  105.  *        v
  106.  *      expr8 --> expr8
  107.  */
  108. expr7   :       expr8
  109.                 (       ( "=="^
  110.                         | "!="^
  111.                         )
  112.                         expr8
  113.                 )*
  114.         ;
  115.  
  116. /*    inequ_op
  117.  *        |
  118.  *        v
  119.  *      expr9 --> expr9
  120.  */
  121. expr8   :       expr9
  122.                 (       ( "\<"^
  123.                         | "\>"^
  124.                         | "\>="^
  125.                         | "\<="^
  126.                         )
  127.                         expr9
  128.                 )*
  129.         ;
  130.  
  131. /*    shift_op
  132.  *        |
  133.  *        v
  134.  *      expr10 --> expr10
  135.  */
  136. expr9   :       expr10
  137.                 (       ( "\>\>"^
  138.                         | "\<\<"^
  139.                         )
  140.                         expr10
  141.                 )*
  142.         ;
  143.  
  144. /*       aop
  145.  *        |
  146.  *        v
  147.  *      expr11 --> expr11
  148.  */
  149. expr10  :   expr11
  150.             (   ( "\+"^
  151.                 | "\-"^
  152.                 )
  153.                 expr11
  154.             )*
  155.         ;
  156.  
  157. /*       mop
  158.  *        |
  159.  *        v
  160.  *      expr12 --> expr12
  161.  *
  162.  */
  163. expr11  :   cast
  164.             (   ( "\*"^
  165.                 | "/"^
  166.                 | "\%"^
  167.                 )
  168.                 cast
  169.             )*
  170.         ;
  171.  
  172. /*       "("
  173.  *        |
  174.  *        v
  175.  *      type --> expr12
  176.  */
  177. cast    :    "\("^ typename "\)"! cast
  178.         |    expr12
  179.         ;
  180.  
  181. /*     unary_op
  182.  *        |
  183.  *        v
  184.  *       "("
  185.  *        |
  186.  *        v
  187.  *     typename
  188.  *        |
  189.  *        v
  190.  *      expr12
  191.  *
  192.  * Or,
  193.  *
  194.  * PreInc_or_PreDec
  195.  *        |
  196.  *        v
  197.  *      expr12
  198.  *
  199.  * Or,
  200.  *
  201.  *     "sizeof"        "sizeof"
  202.  *        |               |
  203.  *        v               v
  204.  *      expr12          "("
  205.  *                       |
  206.  *                       v
  207.  *                     expr12
  208.  */
  209. expr12!    :   <<AST *t=NULL;>>
  210.             unary_op
  211.             { "\(" typename "\)" <<t = #( #[ENode, LPAREN], #2);>> }
  212.             expr12
  213.             <<#0 = #( #(#1, t), #3 );>>
  214.         |   PreInc expr12    <<#0 = #( #[ENode, PreInc], #2 );>>
  215.         |   PreDec expr12    <<#0 = #( #[ENode, PreDec], #2 );>>
  216.         |   "sizeof"
  217.             (   "\(" typename    <<t = #( #[ENode, LPAREN], #2);>>
  218.                 "\)"
  219.             |   expr12            <<t = #1;>>
  220.             )
  221.             <<#0 = #( #[ENode, SizeOf], t );>>
  222.         |   expr13
  223.                                 <<#0 = #1;>>
  224.         ;
  225.  
  226. /*
  227.  * Put a post dec or inc as root of expr13.
  228.  *
  229.  * For WORD expr14 we build:
  230.  *
  231.  *        WORD
  232.  *         |
  233.  *         v
  234.  *        expr14
  235.  *
  236.  * For WORD or expr followed by (...) expr14 we build:
  237.  *
  238.  *      FuncCall
  239.  *         |
  240.  *         v
  241.  *    expr_or_WORD --> expr        (sibling is argument list)
  242.  *         |
  243.  *         v
  244.  *        expr14
  245.  */
  246. expr13!    :   <<Sym *var; AST *e=NULL;>>
  247.         (    STRING        <<#0 = #[ENode, STRING];>>
  248.         |   CHARACTER    <<#0 = #[ENode, CHARACTER];>>
  249.         |   FNUM        <<#0 = #[ENode, FNUM];>>
  250.         |   integer        <<#0 = #1;>>
  251.         |   WORD    <<if ( (var=zzs_get($1.text)) == NULL )
  252.                           error1("undefined variable", $1.text);
  253.                       else 
  254.                           if ( var->token!=Var && var->token!=Func )
  255.                               error1("we were kind of hoping for a variable here",$1.text);
  256.                     >>
  257.             expr14
  258.             <<if ( var!=NULL ) #0 = #( #[ENode, var->token], #2 );>>
  259.         |   WORD    <<var = zzs_get($1.text);
  260.                        if ( var != NULL )
  261.                         {
  262.                         if ( var->token != Func )
  263.                         {
  264.                               error1("we were kind of hoping for a function here",$1.text);
  265.                         }
  266.                         }
  267.                     >>
  268.             "\(" {expr <<e=#1;>>} "\)"
  269.             expr14
  270.             <<#0 = #( #[ENode, FuncCall], #(#[ENode, Func], #5), e );>>
  271.         |   "\(" expr "\)" {"\(" {expr <<e=#1;>>} "\)"} expr14
  272.             <<#0 = #( NULL, #( #[ENode, LPAREN], #2, #5), e );>>
  273.         )
  274.         { "\+\+"        <<#0 = #( #[ENode, PostInc], #0 );>>
  275.         | "\-\-"        <<#0 = #( #[ENode, PostDec], #0 );>>
  276.         }
  277.         ;
  278.  
  279. /*
  280.  * build chains of modifiers.
  281.  *
  282.  * -> or . yields
  283.  *
  284.  *        ->
  285.  *        |
  286.  *        v
  287.  *       WORD
  288.  *        |
  289.  *        v
  290.  *       ...
  291.  *        |
  292.  *        v
  293.  *        ->
  294.  *        |
  295.  *        v
  296.  *       WORD
  297.  *
  298.  * Array refs:
  299.  *
  300.  *       [ ]
  301.  *        |
  302.  *        v
  303.  *       expr                    (first)
  304.  *       ...
  305.  *        |
  306.  *        v
  307.  *       expr                    (last)
  308.  */
  309. expr14!    :   "\-\>" WORD    expr14
  310.             <<#0 = #(#[ENode, StructPtrRef], #[ENode, WORD]);
  311.               #( bottom(#0), #3 );>>
  312.         |   "." WORD expr14
  313.             <<#0 = #(#[ENode, StructRef], #[ENode, WORD]);
  314.               #( bottom(#0), #3 );>>
  315.         |   "\[" expr "\]" expr14
  316.             <<#0 = #(#[ENode, LBRACK], #2);
  317.               #( bottom(#0), #4 );>>
  318.         |    <<#0 = NULL;>>
  319.         ;
  320.  
  321. unary_op:    "&" | "\*" | "\+" | "\-" | "\~" | "!"
  322.         ;
  323.  
  324. integer :   OCT_NUM
  325.         |   HEX_NUM
  326.         |   INT_NUM
  327.         |   L_OCT_NUM
  328.         |   L_HEX_NUM
  329.         |   L_INT_NUM
  330.         ;
  331.  
  332. #token WORD "[_a-zA-Z][_a-zA-Z0-9]*"
  333.         <<{
  334.             register Sym *p;
  335.             p = zzs_get(NLATEXT);
  336.             if ( p != NULL )
  337.                 if ( p->token == TypeName )
  338.                 {
  339.                     NLA = TypeName;
  340.                 }
  341.         }>>
  342.